Un Enfoque Dinámico para Galgas Extensiométicas.#
Objetivos#
Comprender el funcionamiento de los mínimos cuadrados recursivos (RLS) en un caso práctico: Explorar el algoritmo de mínimos cuadrados recursivos mediante la simulación de datos provenientes de una galga extensiométrica, considerada como un sistema dinámico de masa-resorte-amortiguador, permitiendo observar cómo los RLS se aplican para la estimación de parámetros.
Aplicar los mínimos cuadrados recursivos para estimar parámetros físicos del sistema: A través de los datos simulados, estimar los parámetros dinámicos en tiempo discreto y, posteriormente, deducir los parámetros físicos de la galga extensiométrica, como la masa que se coloca sobre ella y que se busca estimar con precisión.
Desarrollar la habilidad de emplear los mínimos cuadrados recursivos en aplicaciones prácticas: Familiarizarse con la implementación y ajuste del algoritmo en Python para llevar a cabo estimaciones en sensores similares, proporcionando las bases necesarias para extender su uso a aplicaciones reales.
Comprender cómo los mínimos cuadrados recursivos aportan inteligencia a los sensores: Analizar cómo el uso del algoritmo permite que un simple sensor de posición, mediante los mínimos cuadrados recursivos, pueda estimar la masa aplicada en tiempo real, incluso durante el transitorio sin necesidad de esperar hasta el estado estacionario, como ocurre con la mayoría de los sensores de masa o básculas. Además, se explora cómo este enfoque permite también la estimación de otros parámetros del sistema, ampliando su aplicabilidad en sistemas de control automático.
Introducción#
Las galgas extensiométricas son ampliamente utilizadas en aplicaciones de medición de deformación, ya que permiten transformar cambios físicos en variaciones de resistencia eléctrica. A pesar de ser catalogadas como sensores resistivos, las galgas poseen una dinámica inherente que debe considerarse en aplicaciones de alta precisión. Aunque comúnmente se les modela como elementos estáticos, en muchas situaciones prácticas, su comportamiento dinámico afecta la precisión de las mediciones, especialmente cuando se integran en sistemas que involucran cambios rápidos o fuerzas en movimiento.
Figura 1 Galga extensiométrica. Imagen obtenida de [Metoreef.].#
Un caso típico de esto se observa en basculas, que son básicamente sensores de pesaje, donde la galga extensiométrica forma parte de un sistema de segundo orden, que puede describirse mediante un modelo masa-resorte-amortiguador. Al modelar correctamente esta dinámica, es posible capturar mejor el comportamiento transitorio del sistema y mejorar la estimación de las fuerzas aplicadas.
En este capítulo se busca mostrar la dinámica de la galga extensiométrica en el contexto de un modelo masa-resorte-amortiguador, específicamente cómo trabajar con dicha dinámica para la estimación de la masa, utilizando técnicas de estimación de parámetros mediante mínimos cuadrados recursivos.
Se comenzará describiendo el modelo masa-resorte-amortiguador en su forma más sencilla.
Figura 2 Sistema Masa-Resorte-Amortiguador. Imagen obtenida de [item24f.].#
donde \(m\) es la masa del sistema, \(b\) es el coeficiente de fricción viscosa, \(k\) es la constante de elasticidad del resorte, \(F(t)\) la fuerza de entrada y \(x(t)\) el desplazamiento presentado debido a \(F(t)\).
Como nos presenta [QC20], un modelo masa-resorte-amortiguador que describe el comportamiento dinámico de una galga extensiométrica es
donde \(m\) es la propia masa del sensor, \(b\) es el coeficiente de fricción viscosa, \(k\) es la constante de elasticidad del resorte, \(g\) es la constante de gravedad y \(u(t)\) es la masa desconocida, siendo aquella masa que se quiere cuantificar.
Estimación de parámetros en Tiempo Discreto con Mínimos Cuadrados Recursivos#
Tomando como referencia los resultados experimentales que validan el comportamiento dinámico del sensor [QC20], se utiliza el modelo en espacio de estados del sensor:
con \(m=0.015[kg]\), \(k=500[N/m]\), \(b = 0.5[N\cdot s /m]\), y \(g = 9.81[m/s^2]\). Estos son los parámetros a utilizar para simular la dinámica del sensor.
Nota
Si se desea realizar modificaciones en el código, favor de ejecutar la siguiente celda para la generación de datos e importación de las bibliotecas necesarias. Una vez ejecutada esta, es posible ejecutar las siguientes con las modificaciones requeridas.
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
from control.matlab import *
from matplotlib.animation import FuncAnimation
from IPython.display import HTML, display, Math
En la siguiente sección de código, se genera la señal de salida, la cual será utilizada como la medición realizada para la estimación en tiempo real.
Show code cell source
# Parámetros físicos del sensor
kn = 500
b = 0.5
m = 0.015
M = 0.1
g = 9.81
# Modelo en espacio de estados
A = np.array([[0, 1], [-kn / (m + M), -b / (m + M)]])
B = np.array([[0], [-g]])
C = np.array([[-1, 0]])
D = np.array([[0]])
# Sistema en tiempo continuo. Representación en espacio de estados
sys_cont = signal.StateSpace(A, B, C, D)
# Tiempo de muestreo y discretización por el método Tustin
T_s = 0.01
sys_disc = sys_cont.to_discrete(T_s, 'tustin')
# Generando los datos de respuesta al escalón
t = np.arange(0, 5, T_s) # Tiempo de simulación
__, y = signal.dstep(sys_disc, t=t) # Respuesta discreta al escalón
y = np.squeeze(y)
# Gráfica de los datos generados
plt.figure(figsize=(10, 8))
plt.plot(y, 'r-', linewidth=4)
plt.grid(True, linestyle='--', color=(0.6, 0.6, 0.6))
plt.xlabel('Muestras', fontsize=14)
plt.ylabel(r'$x\ [m]$', fontsize=14)
plt.show()
Para comenzar con el desarrollo del algoritmo, se debe tener en cuenta que el regresor no será unitario, como en el capítulo anterior. Por lo tanto, es necesario proponer un modelo en tiempo discreto. En particular, al discretizar la función de transferencia del sistema \(H(s)\), se obtiene un modelo con estructura ARMA (AutoRegressive Moving Average), expresado como:
donde los parámetros de la ecuación en diferencias se obtienen a partir del vector de parámetros \(\hat{\theta_k}\)Dada la definición del regresor y considerando que se estimarán 5 parámetros, este debe tener dicha dimensión. Por lo tanto, el regresor puede definirse de la siguiente manera:
de esta forma, se construirá el regresor. Esto se puede observar en la siguiente sección de código, donde se inicializa el algoritmo y se aplica.
Show code cell source
# Factor de olvido para modificar
lambda_ = 0.75
# Inicialización de valores para el algoritmo RLS
P = 1000 * np.eye(5)
theta = np.zeros(5)
estimation = list()
# Simulación de datos de ejemplo
length = len(y)
# Configuración de la gráfica
fig, ax = plt.subplots(figsize=(10, 8))
ax.grid(True, color=[0.6, 0.6, 0.6], linestyle='--')
ax.set_xlim(0, 250)
ax.set_ylim(min(y)-0.0001, max(y)+0.0001)
ax.set_xlabel('Muestras', fontsize=14)
ax.set_ylabel(r'$x\ [m]$', fontsize=14)
# Inicialización para el gráfico
plot_output, = ax.plot([], [], 'r-', linewidth=4, label=r'$x(t)$')
plot_estimation, = ax.plot([], [], 'b--', linewidth=4, label=r'$\hat{x}(t)$')
ax.legend(fontsize=14)
# Función de actualización para cada frame de la animación
def update_rls(k):
global theta, P
# Definimos el vector de regresión
phi = np.array([-y[k - 2], -y[k - 1], 1, 1, 1])
# Error de predicción
epsilon = y[k] - np.dot(phi.T, theta)
# Cálculo de la matriz de covarianza
K = np.dot(P, phi) / (lambda_ + np.dot(np.dot(phi.T, P), phi))
# Ganancia de Kalman
P = (1 / lambda_) * (P - (np.dot(np.dot(P, np.outer(phi, phi)), P)) / (lambda_ + np.dot(np.dot(phi.T, P), phi)) )
# Actualización del vector de parámetros
theta = theta + (K * epsilon)
# Guardamos la estimación realizada
estimation.append(np.dot(phi.T, theta))
# Actualizamos la gráfica
plot_estimation.set_data(range(len(estimation)), estimation)
plot_output.set_data(range(k + 1), y[:k + 1])
return plot_estimation, plot_output
# Configuración de la animación
ani = FuncAnimation(fig, update_rls, frames=range(2, 250), blit=True, interval=50)
plt.close(fig)
HTML(ani.to_jshtml())